package com.smart.modeldesign;

import java.util.HashSet;
import java.util.Set;

/**
 * @PackageName: com.smart.modeldesign
 * @ClassName: ProcessedProducts
 * @Description:  加工产品
 * @author: hgx61
 * @date: 2024/9/20 16:46
 */

public class ProcessedProducts {

  private Set<Machine> aaaMachines;
  private Set<Machine> bbbMachines;
  private Set<Machine> cccMachines;

  private final int Machine_TYPE_A=1;
  private final int Machine_TYPE_B=2;
  private final int Machine_TYPE_C=3;


  public ProcessedProducts() {
    init();
  }


  /**
   * @Description:  初始化
   * @param:
   * @return: void
   * @author: hgx61
   * @date: 2024/9/20 16:47
   */
  private final void init() {
    aaaMachines=new HashSet<>();
    bbbMachines=new HashSet<>();
    cccMachines=new HashSet<>();

    aaaMachines.add(new AaaMachine());
    bbbMachines.add(new BbbMachine());
    cccMachines.add(new CccMachine());
  }

  /**
   * @Description:  加工产品
   * @param: prouctOrder
   * @param: num
   * @return: void
   * @author: hgx61
   * @date: 2024/9/20 16:47
   */
  public void process(ProuctOrder prouctOrder,int num) {
    System.out.println("开始加工产品：===============================");
     for (int i = 0; i < num; i++) {
       disposeTask(prouctOrder.getBaseProduct());
     }

    System.out.println("完成产品加工  *******************************************");

  }

  /**
   * @Description:  处理任务 【模板方法，模板模式】 ,这里可以考虑使用多线程，多线程处理，这里为了简单，直接使用单线程处理
   * @param: product
   * @return: void
   * @author: hgx61
   * @date: 2024/9/20 16:47
   */
  private void disposeTask(BaseProduct product){
    oneMachine(product);
    twoMachine(product);
    threeMachine(product);
  }

  /**
   * @Description:  处理任务  ,这里可以考虑使用多线程，多线程处理，这里为了简单，直接使用单线程处理
   * @param: product
   * @return: void
   * @author: hgx61
   * @date: 2024/9/20 16:47
   */
  private void oneMachine(BaseProduct product) {
    //第一道工序
    Machine aaaMachine = getMachine(Machine_TYPE_A);
    if(aaaMachine !=null ){
      System.out.println("第一道工序  开始加工产品：");
      aaaMachine.process(product);
    }
  }

  private void twoMachine(BaseProduct product) {
    //第二道工序
    Machine bbbMachine = getMachine(Machine_TYPE_B);
    if(bbbMachine !=null ){
      System.out.println("第二道工序  开始加工产品：");
      bbbMachine.process(product);
    }
  }

  private void threeMachine(BaseProduct product) {
    //第三道工序
    Machine cccMachine = getMachine(Machine_TYPE_C);
    if(cccMachine !=null ){
      System.out.println("第三道工序  开始加工产品：");
      cccMachine.process(product);
    }
  }

  private Machine getMachine(int machine_TYPE) {
    switch (machine_TYPE) {
      case Machine_TYPE_A:
        if(aaaMachines.isEmpty()){
          addMachine(Machine_TYPE_A,1);
        }
        return aaaMachines.iterator().next();
      case Machine_TYPE_B:
        if(bbbMachines.isEmpty()){
          addMachine(Machine_TYPE_B,1);
        }
        return bbbMachines.iterator().next();
      case Machine_TYPE_C:
        if(cccMachines.isEmpty()){
          addMachine(Machine_TYPE_C,1);
        }
        return cccMachines.iterator().next();
    }
    return null;
  }

  /**
   * @Description:  添加机器
   * @param: machine_TYPE 机器类型
   * @param: num  数量
   * @return: void
   * @author: hgx61
   * @date: 2024/9/20 16:47
   */
  protected void addMachine(final int machine_TYPE,int num) {
    switch (machine_TYPE) {
      case Machine_TYPE_A:
        for (int i = 0; i < num; i++) {
          aaaMachines.add(new AaaMachine());
        }
        break;
      case Machine_TYPE_B:
        for (int i = 0; i < num; i++) {
          bbbMachines.add(new BbbMachine());
        }
        break;
      case Machine_TYPE_C:
        for (int i =0; i < num; i++) {
          cccMachines.add(new CccMachine());
        }
    }

  }

  /**
   * @Description:  移除机器，当集合中空闲机器较多时，可以移除部分空闲的机器，减少机器的资源消耗，
   * 监控集合中机器的空闲对象，当集合中机器不够用时，可以添加机器【调用 addMachine( ) 方法】；
   * 当集合中空闲机器过多时，可以移除部分机器【调用 removeMachine( ) 方法】，减少机器的资源消耗
   * @param: machine  机器对象
   * @return: void
   * @author: hgx61
   * @date: 2024/9/20 16:47
   */
  protected void removeMachine(Machine machine) {
    if(machine == null){
      return ;
    }

    if(machine instanceof AaaMachine){
      aaaMachines.remove(machine);
    }else if(machine instanceof BbbMachine){
      bbbMachines.remove(machine);
    }else if(machine instanceof CccMachine){
      cccMachines.remove(machine);
    }

  }

}
